const fs = require('fs');
const path = require('path');
const iconv = require('iconv-lite');

// 音标映射表（从server/utils/resourceScanner.js复制）
const phoneticMapping = {
  // 元音
  'A': 'æ',     // bag
  'E': 'ə',     // the
  'I': 'ɪ',     // bit
  'O': 'ɒ',     // hot
  'U': 'ʊ',     // put
  'R': 'ɔ',     // law
  '@': 'ʌ',     // but
  '^': 'ɜ',     // bird
  'e': 'e',     // bed
  'i': 'i',     // bee
  'o': 'ɑ',     // all
  'u': 'u',     // too
  'a': 'ə',     // sofa
  
  // 双元音
  'EI': 'eɪ',   // bay
  'AI': 'aɪ',   // buy
  'OI': 'ɔɪ',   // boy
  'EJ': 'eɪ',   // bay
  'AJ': 'aɪ',   // buy
  'OJ': 'ɔɪ',   // boy
  'IJ': 'aɪ',   // 缺失的映射
  'UJ': 'aʊ',   // brown
  'AU': 'aʊ',   // now
  'OU': 'əʊ',   // go
  'IU': 'əʊ',   // 缺失的映射
  'EA': 'ɪə',   // near
  'IA': 'ɪə',   // near
  'UA': 'ʊə',   // poor
  
  // 辅音
  'B': 'b',
  'C': 'ʃ',
  'D': 'ð',
  'F': 'f',
  'G': 'ɡ',
  'H': 'h',
  'J': 'dʒ',
  'K': 'k',
  'L': 'l',
  'M': 'm',
  'N': 'n',
  'P': 'p',
  'Q': 'kw',
  'S': 's',
  'T': 'θ',
  'V': 'v',
  'W': 'w',
  'X': 'ks',
  'Y': 'j',
  'Z': 'z',
  
  // 特殊符号
  '5': 'ˈ',     // 主重音
  ':': 'ː',     // 长音
  ',': 'ˌ',     // 次重音
  '?': 'ˌ',     // 次重音
  '"': 'ˌ',     // 次重音
};

// 解码音标编码
function decodePhonetic(code) {
  if (!code) return '';
  
  let result = '';
  let i = 0;
  
  while (i < code.length) {
    // 检查两个字符的组合
    if (i < code.length - 1) {
      const twoChar = code.substr(i, 2);
      if (phoneticMapping[twoChar]) {
        result += phoneticMapping[twoChar];
        i += 2;
        continue;
      }
    }
    
    // 检查单个字符
    const oneChar = code[i];
    if (phoneticMapping[oneChar]) {
      result += phoneticMapping[oneChar];
    } else {
      // 如果没有映射，保留原字符
      result += oneChar;
    }
    i += 1;
  }
  
  return '/' + result + '/';
}

// 获取所有字典文件
function getAllDictionaryFiles() {
  const dicDir = path.join(__dirname, '..', 'resources', 'dic');
  const files = [];
  
  function walkDir(dir) {
    const items = fs.readdirSync(dir);
    for (const item of items) {
      const fullPath = path.join(dir, item);
      const stat = fs.statSync(fullPath);
      if (stat.isDirectory()) {
        walkDir(fullPath);
      } else if (stat.isFile() && item.endsWith('.txt')) {
        files.push(fullPath);
      }
    }
  }
  
  walkDir(dicDir);
  return files;
}

// 解析XML内容，提取音标编码
function extractPhoneticFromContent(content) {
  // 查找词典音标标签及其中的内容
  // 首先找到词典音标开始和结束标签的位置
  const startTagIndex = content.indexOf('<词典音标>');
  const endTagIndex = content.indexOf('</词典音标>');
  
  if (startTagIndex !== -1 && endTagIndex !== -1 && endTagIndex > startTagIndex) {
    // 提取标签之间的内容
    const betweenTags = content.substring(startTagIndex + '<词典音标>'.length, endTagIndex);
    
    // 在标签之间查找CDATA
    const cdataMatch = betweenTags.match(/<!$$CDATA$$([^\]]+)$$]]>/);
    if (cdataMatch) {
      return cdataMatch[1];
    }
    
    // 如果没有CDATA，直接返回标签间的内容（去除空白）
    const trimmedContent = betweenTags.trim();
    if (trimmedContent) {
      return trimmedContent;
    }
  }
  
  // 查找所有音标相关标签
  const phoneticStartIndex = content.indexOf('<单词音标>');
  const phoneticEndIndex = content.indexOf('</单词音标>');
  
  if (phoneticStartIndex !== -1 && phoneticEndIndex !== -1 && phoneticEndIndex > phoneticStartIndex) {
    const betweenTags = content.substring(phoneticStartIndex + '<单词音标>'.length, phoneticEndIndex);
    
    // 在标签之间查找CDATA
    const cdataMatch = betweenTags.match(/<!$$CDATA$$([^\]]+)$$]]>/);
    if (cdataMatch) {
      return cdataMatch[1];
    }
  }

  // 查找所有CDATA内容
  const cdataMatches = content.match(/<!$$CDATA$$([^]]+?)$$]]>/g);
  
  if (cdataMatches) {
    // 遍历所有CDATA内容，查找可能的音标编码
    for (let i = 0; i < cdataMatches.length; i++) {
      const cdata = cdataMatches[i];
      const codeMatch = cdata.match(/<!$$CDATA$$([^]]+?)$$]]>/);
      if (codeMatch) {
        const code = codeMatch[1];
        // 判断是否为有效的音标编码
        if (typeof code === 'string' &&
            code.length >= 3 && 
            code.length <= 30 &&
            /^[A-Za-z0-9@:5^\]\(\); \-?]+$/.test(code)) {
          // 优先选择包含典型音标编码特征的内容
          if (/[0-9@:5^]/.test(code)) {
            return code;
          }
        }
      }
    }
    
    // 如果没有找到带特殊字符的，至少返回一个看起来合理的
    for (let i = 0; i < cdataMatches.length; i++) {
      const cdata = cdataMatches[i];
      const codeMatch = cdata.match(/<!$$CDATA$$([^]]+?)$$]]>/);
      if (codeMatch) {
        const code = codeMatch[1];
        if (typeof code === 'string' &&
            code.length >= 3 && 
            code.length <= 30 &&
            /^[A-Za-z0-9@:5^\]\(\); \-?]+$/.test(code)) {
          return code;
        }
      }
    }
  }
  
  return null;
}

// 生成完整报告
function generateReport() {
  console.log('开始生成音标映射分析报告...');
  
  const allFiles = getAllDictionaryFiles();
  console.log(`总共找到 ${allFiles.length} 个字典文件`);
  
  const results = [];
  let processedCount = 0;
  
  for (const filePath of allFiles) {
    try {
      // 使用iconv-lite读取GBK编码的文件
      const buffer = fs.readFileSync(filePath);
      const content = iconv.decode(buffer, 'gbk');
      
      const phoneticCode = extractPhoneticFromContent(content);
      
      if (phoneticCode) {
        const decoded = decodePhonetic(phoneticCode);
        const fileName = path.basename(filePath, '.txt');
        
        results.push({
          word: fileName,
          code: phoneticCode,
          decoded: decoded
        });
      }
      
      processedCount++;
      if (processedCount % 1000 === 0) {
        console.log(`已处理 ${processedCount}/${allFiles.length} 个文件...`);
        console.log(`已找到 ${results.length} 个音标编码`);
      }
    } catch (error) {
      console.error(`处理文件 ${filePath} 时出错:`, error.message);
    }
  }
  
  // 生成报告
  const report = {
    totalFiles: allFiles.length,
    processedFiles: processedCount,
    successfulExtractions: results.length,
    successRate: (results.length / processedCount * 100).toFixed(2),
    sampleResults: results.slice(0, 50), // 前50个示例
    statistics: {
      withSpecialChars: results.filter(r => /[5:@^]/.test(r.code)).length,
      withIPAChars: results.filter(r => /[ˈˌæəɪʃʒðθŋɔʌʊɛɜ]/.test(r.decoded)).length
    }
  };
  
  // 写入报告文件
  const reportPath = path.join(__dirname, 'phonetic-analysis-report.json');
  fs.writeFileSync(reportPath, JSON.stringify(report, null, 2));
  
  // 写入CSV格式的结果文件
  const csvPath = path.join(__dirname, 'phonetic-results.csv');
  const csvContent = 'Word,Encoded,Decoded\n' + 
    results.map(r => `"${r.word}","${r.code}","${r.decoded}"`).join('\n');
  fs.writeFileSync(csvPath, csvContent);
  
  console.log('\n分析报告已生成:');
  console.log(`- 报告文件: ${reportPath}`);
  console.log(`- CSV文件: ${csvPath}`);
  console.log(`- 总文件数: ${report.totalFiles}`);
  console.log(`- 成功提取: ${report.successfulExtractions}`);
  console.log(`- 成功率: ${report.successRate}%`);
  console.log(`- 含特殊字符编码: ${report.statistics.withSpecialChars}/${report.successfulExtractions} (${(report.statistics.withSpecialChars/report.successfulExtractions*100).toFixed(2)}%)`);
  console.log(`- 含IPA音标: ${report.statistics.withIPAChars}/${report.successfulExtractions} (${(report.statistics.withIPAChars/report.successfulExtractions*100).toFixed(2)}%)`);
  
  // 显示一些示例
  console.log('\n示例结果:');
  console.log('========================');
  report.sampleResults.forEach(result => {
    console.log(`${result.word}: ${result.code} -> ${result.decoded}`);
  });
}

// 运行报告生成
generateReport();